/*****************************************************************************/
/*                        >>> func_config.c <<<                              */
/*	Trabajo Practico 2do. cuatrimestre 2011                                  */
/*	TP:"FUSELAJE"                                                            */
/*	GRUPO: Reduce Fat Fast                                                   */
/*	INTEGRANTES: Emanuel Genovese                                            */
/*               Federico Gabriel Garcia                                     */
/*               Federico Pioli                                              */
/*               Esther Insfrain                                             */
/*               Luciano Bagattin                                            */
/*	Fecha UM:                                                                */
/*****************************************************************************/
/*****************************************************************************/
/*		        	Include		                                             */
/*****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "../headers/estructuras.h"
#include "../headers/func_config.h"
#include "../headers/constantes.h"
#include "func_strings.h"
#include "log.h"
#include "string.h"
/*****************************************************************************/
/*		        	Define		                                             */
/*****************************************************************************/




/******************************************************************************/
/* Nombre de Funcion: ifCargaArchivo                                          */
/* Parametros: puntero: cmrMatriz de lineas de arch config                    */
/*																			  */
/*	                                                                          */
/* Descripcion: Funcion que levanta los datos del archivo de configuracion    */
/******************************************************************************/

int ifCargaArchivo(char cmrMatriz [][80+2])
{
    FILE * pstArchi;
    int iFila,iLong;
    char szLinea[80+2];


	iFila=0;
	if ((pstArchi = fopen(PFS_CONFIG,"rt"))==NULL)
	    return (1);

	while((fgets(szLinea, 80, pstArchi))!=NULL){
	    iLong=strlen(szLinea);
	    if(szLinea[iLong-1]=='\n')
		szLinea[iLong-1]='\0';

	    if(szLinea[0] != '#'){
		 bzero(cmrMatriz[iFila],82);
		 strncpy(cmrMatriz[iFila],szLinea,strlen(szLinea));
		 cmrMatriz[iFila][strlen(cmrMatriz[iFila])]='\0';
		 iFila++;
	    }
	}
	fclose(pstArchi);
	return (EXIT_SUCCESS);
}//fin del fCargaConfig

/******************************************************************************/
/* Nombre de Procedimiento: pCargaArchConfig                                  */
/* Parametros: stInfoConfig:estructura de arch config                         */
/*                                                                            */
/*	                                                                          */
/* Descripcion:Procedimiento que carga el archivo de configuracion en una     */
/* struct                                                                     */
/******************************************************************************/

int fLoadConfig(datosConfig * st, t_log * log){
 /* comienzo de declaracion de variables globales */


	 char sAux[1000]="\0";
     char sCHS[256]="\0";
     char cmConfig[17][80+2];

     /* fin de declaracion de variables locales */



     if (ifCargaArchivo(cmConfig)){
	  	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo abrir el archivo");
	  	return 1;
     }
	 log_info(log, SNOMBREPROCESO, "Message info: %s", "El archivo de configuracion se abrio con exito");


     //asignacion de Modo Inicio
    if (strlen(cmConfig[0]) == 0){
	  	printf ("No se pudo obtener los datos del archivo\n\n");
	  	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el modo de Inicio");
	  	return 1;
	}
    strcpy(st->sModoInicio,cmConfig[0]);
    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el modo de inicio");



    if (strlen(cmConfig[1]) == 0){
	  	printf ("No se pudo obtener los datos del archivo\n\n");
	  	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener la ip local");
	  	return 1;
	}

	strcpy(st->sIpLocal,cmConfig[1]);
	log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito la ip local");




	//asignacion PuertoLocal
	if (strlen(cmConfig[2]) == 0){
		printf ("No se pudo obtener los datos del archivo\n\n");
		log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el Puerto local");
		return 1;
	}

	st->iPuertoLocal=atoi(cmConfig[2]);
	log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito la Puerto Local");

	//obtenemos la ip del RAID
	if (strlen(cmConfig[3]) == 0){
			printf ("No se pudo obtener los datos del archivo\n\n");
			log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener la ip del RAID");
			return 1;
	}

	strcpy(st->sIPRAID,cmConfig[3]);
	log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito la ip del RAID");

	/*Obtenemos el puerto del RAID*/
	if (strlen(cmConfig[4]) == 0){
				printf ("No se pudo obtener los datos del archivo\n\n");
				log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el puerto del RAID");
				return 1;
	}
	st->iPuertoRAID=atoi(cmConfig[4]);
	log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el puerto del RAID");

	//Obtenemos si la consola esta activada

	if (strlen(cmConfig[5]) == 0){
		printf ("No se pudo obtener los datos del archivo\n\n");
		log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el flag de consola");
		return 1;
	}

	strcpy(st->sConsola,cmConfig[5]);
	log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el flag de consola");




    //Obtenemos el algoritmo de planificacion
    if (strlen(cmConfig[6]) == 0){
    	printf ("No se pudo obtener los datos del archivo\n\n");
    	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener  el algoritmo de planificacion");
    	return 1;
    }
    strcpy(st->sAlgo_Planif,cmConfig[6]);
    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el algoritmo de planificacion");




    //asignacion Puerto de la consola
    if (strlen(cmConfig[7]) == 0){
    	printf ("No se pudo obtener los datos del archivo\n\n");
    	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener la ruta de la  Consola");
    	return 1;
    }
    strcpy(st->sPathConsola,cmConfig[7]);

    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito la ruta  de la Consola");



    //asignacion flag de logs
    if (strlen(cmConfig[8]) == 0){
     	printf ("No se pudo obtener los datos del archivo\n\n");
       	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el flag de logs");
       	return 1;
    }
    strcpy(st->sLogs,cmConfig[8]);
    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el flag de logs");



    //asignacion flag de logs
    if (strlen(cmConfig[9]) == 0){
      	printf ("No se pudo obtener los datos del archivo\n\n");
       	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el identificador del ppd");
       return 1;
    }
    strcpy(st->sIdDisco,cmConfig[9]);
    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el identificador del ppd");



    memset(sAux,'\0', 1000);


    //asignacion flag de logs
    if (strlen(cmConfig[10]) == 0){
      	printf ("No se pudo obtener los datos del archivo\n\n");
       	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el CHS");
       	return 1;
    }
    strcpy(sCHS,cmConfig[10]);
    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el CHS");


    pSepacadCHS(sCHS);
    st->iCilindros=iCilindros;
    st->iCabeza=iCabezales;
    st->iSectores=iSectores;




    if (strlen(cmConfig[11]) == 0){
          	printf ("No se pudo obtener los datos del archivo\n\n");
           	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el tiempo de lectura");
           	return 1;
    }

    st->iTiempoLectura=atoi(cmConfig[11]);





    if (strlen(cmConfig[12]) == 0){
          	printf ("No se pudo obtener los datos del archivo\n\n");
           	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el tiempo de escritura");
           return 1;
    }

    st->iTiempoEscritura=atoi(cmConfig[12]);





    if (strlen(cmConfig[13]) == 0){
         printf ("No se pudo obtener los datos del archivo\n\n");
         log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el rpm");
        return 1;
    }


    st->iRPM=atoi(cmConfig[13]);


    if (strlen(cmConfig[14]) == 0){
                	printf ("No se pudo obtener los datos del archivo\n\n");
                 	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el tiempo de busqueda");
                 	return 1;
    }

    st->fTiempoBusqueda=(float)atof(cmConfig[14]);


    /*cargo el modo de cache*/
    if (strlen(cmConfig[15]) == 0){
        	printf ("No se pudo obtener los datos del archivo\n\n");
        	log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el modo de cache");
        	return 1;
    }

    memset(st->sCache, '\0', 2);

    strcpy(st->sCache,cmConfig[15]);


    log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el modo de cache");

    /*cargo el modo de cache*/
     if (strlen(cmConfig[16]) == 0){
            printf ("No se pudo obtener los datos del archivo\n\n");
            log_error(log, SNOMBREPROCESO, "Message error: %s", "No se pudo obtener el tiempo de cache");
            return 1;
     }

     st->fTiempoCache=atof(cmConfig[16]);
     log_info(log, SNOMBREPROCESO, "Message info: %s", "Se obtuvo con exito el tiempo  de cache");


	log_info(log, SNOMBREPROCESO, "Message info: %s", "El archivo de Config. se cerro exitosamente");

  return EXIT_SUCCESS;

}//fin del fLoadConfig

/******************************************************************************/
/* Nombre de Procedimiento: pSepacadCHS                                       */
/* Parametros: sPar_thread: Cadena a convertir a numero                       */
/* Descripcion: Procedimiento que se encarga de pasar a tres variables        */
/*              globales (cilindros, sectores y cabeza) la cadena de CHS      */
/******************************************************************************/


void pSepacadCHS(char* sPar_thread){
        char Aux[10];
        int a=0;
        int i=0;

        for(a=0;sPar_thread[i]!=',';i++)
                Aux[a++]=sPar_thread[i];
        Aux[a]='\0';
        pCadaInt(Aux,&iCilindros);
        memset(Aux,'\0',strlen(Aux));
        for(a=0,i++;sPar_thread[i]!=',';i++)
                Aux[a++]=sPar_thread[i];
        Aux[a]='\0';

        pCadaInt(Aux,&iCabezales);
        memset(Aux,'\0',strlen(Aux));
        for(a=0,i++;sPar_thread[i]!=',';i++)
                Aux[a++]=sPar_thread[i];

        Aux[a]='\0';
        pCadaInt(Aux,&iSectores);
        memset(Aux,'\0',strlen(Aux));
}//fin del pSepacadCHS



